home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / system-config-printer / authconn.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  14.3 KB  |  406 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import threading
  5. import cups
  6. import cupspk
  7. import gobject
  8. import gtk
  9. import os
  10. from errordialogs import *
  11. from debug import *
  12.  
  13. _ = lambda x: x
  14.  
  15. N_ = lambda x: x
  16.  
  17. def set_gettext_function(fn):
  18.     global _
  19.     _ = fn
  20.  
  21.  
  22. class AuthDialog(gtk.Dialog):
  23.     AUTH_FIELD = {
  24.         'username': N_('Username:'),
  25.         'password': N_('Password:'),
  26.         'domain': N_('Domain:') }
  27.     
  28.     def __init__(self, title = None, parent = None, flags = gtk.DIALOG_MODAL | gtk.DIALOG_NO_SEPARATOR, buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK), auth_info_required = [
  29.         'username',
  30.         'password'], allow_remember = False):
  31.         if title == None:
  32.             title = _('Authentication')
  33.         
  34.         gtk.Dialog.__init__(self, title, parent, flags, buttons)
  35.         self.auth_info_required = auth_info_required
  36.         self.set_default_response(gtk.RESPONSE_OK)
  37.         self.set_border_width(6)
  38.         self.set_resizable(False)
  39.         hbox = gtk.HBox(False, 12)
  40.         hbox.set_border_width(6)
  41.         image = gtk.Image()
  42.         image.set_from_stock(gtk.STOCK_DIALOG_AUTHENTICATION, gtk.ICON_SIZE_DIALOG)
  43.         image.set_alignment(0, 0)
  44.         hbox.pack_start(image, False, False, 0)
  45.         vbox = gtk.VBox(False, 12)
  46.         self.prompt_label = gtk.Label()
  47.         vbox.pack_start(self.prompt_label, False, False, 0)
  48.         num_fields = len(auth_info_required)
  49.         table = gtk.Table(num_fields, 2)
  50.         table.set_row_spacings(6)
  51.         table.set_col_spacings(6)
  52.         self.field_entry = []
  53.         for i in range(num_fields):
  54.             field = auth_info_required[i]
  55.             label = gtk.Label(_(self.AUTH_FIELD.get(field, field)))
  56.             label.set_alignment(0, 0.5)
  57.             table.attach(label, 0, 1, i, i + 1)
  58.             entry = gtk.Entry()
  59.             entry.set_visibility(field != 'password')
  60.             table.attach(entry, 1, 2, i, i + 1, 0, 0)
  61.             self.field_entry.append(entry)
  62.         
  63.         self.field_entry[num_fields - 1].set_activates_default(True)
  64.         vbox.pack_start(table, False, False, 0)
  65.         hbox.pack_start(vbox, False, False, 0)
  66.         self.vbox.pack_start(hbox)
  67.         if allow_remember:
  68.             cb = gtk.CheckButton(_('Remember password'))
  69.             cb.set_active(False)
  70.             vbox.pack_start(cb)
  71.             self.remember_checkbox = cb
  72.         
  73.         self.vbox.show_all()
  74.  
  75.     
  76.     def set_prompt(self, prompt):
  77.         self.prompt_label.set_markup('<span weight="bold" size="larger">' + prompt + '</span>')
  78.         self.prompt_label.set_use_markup(True)
  79.         self.prompt_label.set_alignment(0, 0)
  80.         self.prompt_label.set_line_wrap(True)
  81.  
  82.     
  83.     def set_auth_info(self, auth_info):
  84.         for i in range(len(self.field_entry)):
  85.             self.field_entry[i].set_text(auth_info[i])
  86.         
  87.  
  88.     
  89.     def get_auth_info(self):
  90.         return map((lambda x: x.get_text()), self.field_entry)
  91.  
  92.     
  93.     def get_remember_password(self):
  94.         
  95.         try:
  96.             return self.remember_checkbox.get_active()
  97.         except AttributeError:
  98.             return False
  99.  
  100.  
  101.     
  102.     def field_grab_focus(self, field):
  103.         i = self.auth_info_required.index(field)
  104.         self.field_entry[i].grab_focus()
  105.  
  106.  
  107.  
  108. class Connection:
  109.     
  110.     def __init__(self, parent = None, try_as_root = True, lock = False, host = None, port = None, encryption = None):
  111.         if host != None:
  112.             cups.setServer(host)
  113.         
  114.         if port != None:
  115.             cups.setPort(port)
  116.         
  117.         if encryption != None:
  118.             cups.setEncryption(encryption)
  119.         
  120.         self._use_password = ''
  121.         self._parent = parent
  122.         self._try_as_root = try_as_root
  123.         self._use_user = cups.getUser()
  124.         self._server = cups.getServer()
  125.         self._port = cups.getPort()
  126.         self._encryption = cups.getEncryption()
  127.         self._prompt_allowed = True
  128.         self._operation_stack = []
  129.         self._lock = lock
  130.         self._gui_event = threading.Event()
  131.         self._connect()
  132.  
  133.     
  134.     def _begin_operation(self, operation):
  135.         self._operation_stack.append(operation)
  136.  
  137.     
  138.     def _end_operation(self):
  139.         self._operation_stack.pop()
  140.  
  141.     
  142.     def _get_prompt_allowed(self):
  143.         return self._prompt_allowed
  144.  
  145.     
  146.     def _set_prompt_allowed(self, allowed):
  147.         self._prompt_allowed = allowed
  148.  
  149.     
  150.     def _set_lock(self, whether):
  151.         self._lock = whether
  152.  
  153.     
  154.     def _connect(self):
  155.         cups.setUser(self._use_user)
  156.         if (self._server[0] == '/' or self._server == 'localhost') and not (self._lock):
  157.             pass
  158.         self._use_pk = os.getuid() != 0
  159.         if self._use_pk:
  160.             create_object = cupspk.Connection
  161.         else:
  162.             create_object = cups.Connection
  163.         self._connection = create_object(host = self._server, port = self._port, encryption = self._encryption)
  164.         if self._use_pk:
  165.             self._connection.set_parent(self._parent)
  166.         
  167.         self._user = self._use_user
  168.         debugprint('Connected as user %s' % self._user)
  169.         methodtype_lambda = type(self._connection.getPrinters)
  170.         methodtype_real = type(self._connection.addPrinter)
  171.         for fname in dir(self._connection):
  172.             if fname[0] == '_':
  173.                 continue
  174.             
  175.             fn = getattr(self._connection, fname)
  176.             if type(fn) not in [
  177.                 methodtype_lambda,
  178.                 methodtype_real]:
  179.                 continue
  180.             
  181.             setattr(self, fname, self._make_binding(fname, fn))
  182.         
  183.  
  184.     
  185.     def _make_binding(self, fname, fn):
  186.         return (lambda : self._authloop(fname, fn, *args, **kwds))
  187.  
  188.     
  189.     def _authloop(self, fname, fn, *args, **kwds):
  190.         self._passes = 0
  191.         c = self._connection
  192.         retry = False
  193.         while retry or self._perform_authentication() != 0:
  194.             if c != self._connection:
  195.                 fn = getattr(self._connection, fname)
  196.                 c = self._connection
  197.             
  198.             cups.setUser(self._use_user)
  199.             
  200.             try:
  201.                 result = fn.__call__(*args, **kwds)
  202.                 if fname == 'adminGetServerSettings':
  203.                     if result == { }:
  204.                         raise cups.IPPError(cups.IPP_NOT_AUTHORIZED, '')
  205.                     result == { }
  206.                 
  207.             continue
  208.             except cups.IPPError:
  209.                 (e, m) = None
  210.                 if self._use_pk and m == 'pkcancel':
  211.                     title = _('Unauthorized request (%s)') % fname
  212.                     text = _('You are not authorized to carry out the requested action.')
  213.                     show_error_dialog(title, text, None)
  214.                     raise cups.IPPError(0, _('Operation canceled'))
  215.                 m == 'pkcancel'
  216.                 if not (self._cancel):
  217.                     pass
  218.                 None if e == cups.IPP_NOT_AUTHORIZED or e == cups.IPP_FORBIDDEN else e == cups.IPP_FORBIDDEN
  219.                 if not (self._cancel) and e == cups.IPP_SERVICE_UNAVAILABLE:
  220.                     if self._lock:
  221.                         self._gui_event.clear()
  222.                         gobject.timeout_add(1, self._ask_retry_server_error, m)
  223.                         self._gui_event.wait()
  224.                     else:
  225.                         self._ask_retry_server_error(m)
  226.                     if self._retry_response == gtk.RESPONSE_OK:
  227.                         debugprint('retrying operation...')
  228.                         retry = True
  229.                         self._passes -= 1
  230.                     else:
  231.                         self._cancel = True
  232.                         raise 
  233.                 self._retry_response == gtk.RESPONSE_OK
  234.                 if self._cancel and not (self._cannot_auth):
  235.                     raise cups.IPPError(0, _('Operation canceled'))
  236.                 not (self._cannot_auth)
  237.                 raise 
  238.                 continue
  239.                 except cups.HTTPError:
  240.                     (s,) = None
  241.                     if not (self._cancel):
  242.                         pass
  243.                     None if s == cups.HTTP_UNAUTHORIZED or s == cups.HTTP_FORBIDDEN else s == cups.HTTP_FORBIDDEN
  244.                     raise 
  245.                     continue
  246.                 
  247.                 None<EXCEPTION MATCH>cups.HTTPError
  248.             return result
  249.  
  250.  
  251.     
  252.     def _ask_retry_server_error(self, message):
  253.         if self._lock:
  254.             gtk.gdk.threads_enter()
  255.         
  256.         
  257.         try:
  258.             msg = _('CUPS server error (%s)') % self._operation_stack[0]
  259.         except IndexError:
  260.             msg = _('CUPS server error')
  261.  
  262.         d = gtk.MessageDialog(self._parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_NONE, msg)
  263.         d.format_secondary_text(_("There was an error during the CUPS operation: '%s'." % message))
  264.         d.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, _('Retry'), gtk.RESPONSE_OK)
  265.         d.set_default_response(gtk.RESPONSE_OK)
  266.         if self._lock:
  267.             d.connect('response', self._on_retry_server_error_response)
  268.             gtk.gdk.threads_leave()
  269.         else:
  270.             self._retry_response = d.run()
  271.             d.destroy()
  272.  
  273.     
  274.     def _on_retry_server_error_response(self, dialog, response):
  275.         self._retry_response = response
  276.         dialog.destroy()
  277.         self._gui_event.set()
  278.  
  279.     
  280.     def _failed(self, forbidden = False):
  281.         self._has_failed = True
  282.         self._forbidden = forbidden
  283.  
  284.     
  285.     def _password_callback(self, prompt):
  286.         debugprint('Got password callback')
  287.         if self._cancel or self._auth_called:
  288.             return ''
  289.         self._auth_called = True
  290.         self._prompt = prompt
  291.         return self._use_password
  292.  
  293.     
  294.     def _perform_authentication(self):
  295.         self._passes += 1
  296.         debugprint('Authentication pass: %d' % self._passes)
  297.         if self._passes == 1:
  298.             self._has_failed = False
  299.             self._forbidden = False
  300.             self._auth_called = False
  301.             self._cancel = False
  302.             self._cannot_auth = False
  303.             self._dialog_shown = False
  304.             cups.setPasswordCB(self._password_callback)
  305.             debugprint('Authentication: password callback set')
  306.             return 1
  307.         debugprint('Forbidden: %s' % self._forbidden)
  308.         if not self._has_failed:
  309.             debugprint('Authentication: Operation successful')
  310.             return 0
  311.         self._has_failed = False
  312.         if self._passes >= 2:
  313.             pass
  314.         if not self._prompt_allowed:
  315.             debugprint('Authentication: prompting not allowed')
  316.             self._cancel = True
  317.             return 1
  318.         if not self._auth_called:
  319.             debugprint('Authentication: giving up')
  320.             self._cancel = True
  321.             self._cannot_auth = True
  322.             return 1
  323.         self._auth_called = False
  324.         if self._cancel:
  325.             debugprint('cancelled')
  326.             return -1
  327.         cups.setUser(self._use_user)
  328.         debugprint('Authentication: Reconnect')
  329.         self._connect()
  330.         return 1
  331.  
  332.     
  333.     def _show_not_authorized_dialog(self):
  334.         if self._lock:
  335.             gtk.gdk.threads_enter()
  336.         
  337.         d = gtk.MessageDialog(self._parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE)
  338.         d.set_title(_('Not authorized'))
  339.         d.set_markup('<span weight="bold" size="larger">' + _('Not authorized') + '</span>\n\n' + _('The password may be incorrect.'))
  340.         if self._lock:
  341.             d.connect('response', self._on_not_authorized_dialog_response)
  342.             d.show_all()
  343.             d.show_now()
  344.             gtk.gdk.threads_leave()
  345.         else:
  346.             d.run()
  347.             d.destroy()
  348.  
  349.     
  350.     def _on_not_authorized_dialog_response(self, dialog, response):
  351.         self._gui_event.set()
  352.         dialog.destroy()
  353.  
  354.     
  355.     def _perform_authentication_with_dialog(self):
  356.         if self._lock:
  357.             gtk.gdk.threads_enter()
  358.         
  359.         if len(self._operation_stack) > 0:
  360.             
  361.             try:
  362.                 title = _('Authentication (%s)') % self._operation_stack[0]
  363.             except IndexError:
  364.                 title = _('Authentication')
  365.  
  366.             d = AuthDialog(title = title, parent = self._parent)
  367.         else:
  368.             d = AuthDialog(parent = self._parent)
  369.         d.set_prompt(self._prompt)
  370.         d.set_auth_info([
  371.             self._use_user,
  372.             ''])
  373.         d.field_grab_focus('password')
  374.         d.set_keep_above(True)
  375.         d.show_all()
  376.         d.show_now()
  377.         self._dialog_shown = True
  378.         if self._lock:
  379.             d.connect('response', self._on_authentication_response)
  380.             gtk.gdk.threads_leave()
  381.         else:
  382.             response = d.run()
  383.             self._on_authentication_response(d, response)
  384.  
  385.     
  386.     def _on_authentication_response(self, dialog, response):
  387.         (self._use_user, self._use_password) = dialog.get_auth_info()
  388.         dialog.destroy()
  389.         if response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT:
  390.             self._cancel = True
  391.         
  392.         if self._lock:
  393.             self._gui_event.set()
  394.         
  395.  
  396.  
  397. if __name__ == '__main__':
  398.     gtk.gdk.threads_init()
  399.     from timedops import TimedOperation
  400.     set_debugging(True)
  401.     c = TimedOperation(Connection, args = (None,)).run()
  402.     debugprint('Connected')
  403.     c._set_lock(True)
  404.     print TimedOperation(c.getFile, args = ('/admin/conf/cupsd.conf', '/dev/stdout')).run()
  405.  
  406.